/* #include <stdio.h>
#include <unistd.h>

int main()
{
    while (1)
    {
        printf("hello signal!\n");
        sleep(1);
    }
    return 0;
} */

/* #include <stdio.h>
#include <signal.h>
#include <unistd.h>

void handler(int sig)
{
    printf("get a signal:%d\n", sig);
}

int main()
{
    // signal(2, handler); // 注册2号信号
    while (1)
    {
        printf("hello signal!\n");
        sleep(1);
    }
    return 0;
} */

/* #include <iostream>
int main()
{
    int a = 10;
    a = a / 0; // 这将引发SIGFPE信号
    return 0;
} */

/* #include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <cstdio>
#include <signal.h>

void handler(int sig)
{
    printf("get a signal:%d\n", sig);
}

int main()
{
    signal(2, handler); // 注册2号信号
    while (true)
    {
        printf("我是一个进程，我的PID:%d\n", getpid());
        sleep(1);
    }
} */

/* #include <iostream>
#include <unistd.h>
#include <signal.h>

void handler(int signumber)
{
    // 整个代码就只有一处打印
    std::cout << "获取了一个信号: " << signumber << std::endl;
}

// mykill -signumber pid
int main()
{
    signal(2, handler); // 先对2号信号进行捕捉
    // 每隔1s，自己给自己发送2号信号
    while (true)
    {
        sleep(1);
        raise(2);
    }
} */

/* #include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>

void handler(int signumber)
{
    // 整个代码就有这一处打印
    std::cout << "获取了一个信号: " << signumber << std::endl;
}

// mykill -signumber pid
int main()
{
    signal(SIGABRT, handler);
    while (true)
    {
        sleep(1);
        abort();
    }
} */

/* #include <stdio.h>
#include <unistd.h>

int main()
{
    sleep(1);
    int *p = NULL;
    *p = 100;

    while (1)
        ;
    return 0;
} */

/* #include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main()
{
    int fd[2] = {0};
    // 使用pipe创建匿名管道
    if (pipe(fd) < 0)
    {
        perror("pipe");
        return 1;
    }

    pid_t id = fork(); // 使用fork创建子进程
                       // child
    if (id == 0)
    {
        close(fd[0]); // 子进程关闭读端
        // 子进程向管道写入数据
        const char *msg = "hello father, I am child...";
        int count = 10;
        while (count--)
        {
            write(fd[1], msg, strlen(msg));
            sleep(1);
        }

        close(fd[1]); // 子进程写入完毕，关闭文件
        exit(0);
    }

    // father
    close(fd[1]); // 父进程关闭写端
    close(fd[0]); // 父进程直接关闭读端（导致子进程被操作系统杀掉）

    int status = 0;
    waitpid(id, &status, 0);
    printf("child get signal:%d\n", status & 0x7F); // 打印子进程收到的信号

    return 0;
}
 */

/* #include <iostream>
#include <signal.h>
#include <unistd.h>

void handler(int sig)
{
    std::cout << "get a signal: " << sig << std::endl;
}

int main()
{
    // 捕捉所有信号
    for (int i = 1; i <= 31; ++i)
    {
        signal(i, handler);
    }

    alarm(1); // Set a 1-second alarm

    while (true)
        ; // Loop forever

    return 0;
} */

/* #include <iostream>
#include <signal.h>
#include <unistd.h>

int main()
{
    long count = 0;
    alarm(1);
    while (true)
    {
        std::cout << "count=" << count++ << std::endl;
    }
    return 0;
} */

/* #include <iostream>
#include <signal.h>
#include <unistd.h>

long count = 0;

void handler(int sig)
{
    std::cout << "Final count: " << count << std::endl;
    exit(0);
}

int main()
{
    signal(SIGALRM, handler);
    alarm(1);
    while (true)
    {
        count++; // Pure computation
    }
    return 0;
} */

/* #include <iostream>
#include <signal.h>
#include <unistd.h>

void handler(int sig)
{
    std::cout << "tick..." << std::endl;
    alarm(1); // Re-register the alarm
}

int main()
{
    signal(SIGALRM, handler);
    alarm(1); // Start the first alarm

    // Efficiently wait for signals
    while (true)
    {
        pause();
    }

    return 0;
} */

/* #include <stdio.h>
#include <unistd.h>
#include <signal.h>

void printPending(sigset_t *pending)
{
    int i = 1;
    for (i = 1; i <= 31; i++)
    {
        if (sigismember(pending, i))
        {
            printf("1 ");
        }
        else
        {
            printf("0 ");
        }
    }
    printf("\n");
}

int main()
{
    sigset_t set, oset;
    sigemptyset(&set);
    sigemptyset(&oset);

    sigaddset(&set, 2);                    // SIGINT
    sigprocmask(SIG_SETMASK, &set, &oset); // 阻塞2号信号

    sigset_t pending;
    sigemptyset(&pending);

    while (1)
    {
        sigpending(&pending);   // 获取pending
        printPending(&pending); // 打印pending位图（1表示未决）
        sleep(1);
    }
    return 0;
} */

/* #include <stdio.h>
#include <signal.h>

int flag = 0;

void handler(int signo)
{
    printf("get a signal:%d\n", signo);
    flag = 1;
}
int main()
{
    signal(2, handler);
    while (!flag)
        ;
    printf("Proc Normal Quit!\n");
    return 0;
} */

/* #include <stdio.h>
#include <signal.h>

volatile int flag = 0;

void handler(int signo)
{
    printf("get a signal:%d\n", signo);
    flag = 1;
}
int main()
{
    signal(2, handler);
    while (!flag)
        ;
    printf("Proc Normal Quit!\n");
    return 0;
} */

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/wait.h>

void handler(int signo)
{
    printf("get a signal: %d\n", signo);
    int ret = 0;
    while ((ret = waitpid(-1, NULL, WNOHANG)) > 0)
    {
        printf("wait child %d success\n", ret);
    }
}

int main()
{
    signal(SIGCHLD, handler);

    // child
    if (fork() == 0)
    {
        printf("child is running, begin dead: %d\n", getpid());
        sleep(3);
        exit(1);
    }

    // father
    while (1)
        ;

    return 0;
}